package com.zlyx.easy.core.tool;

import java.lang.reflect.Method;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.Random;
import java.util.UUID;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.zlyx.easy.core.utils.DateUtils;
import com.zlyx.easy.core.utils.HexUtils;

/**
 * @Auth 赵光
 * @Describle 提供了大量基础功能的Bean接口
 * @2019年4月19日
 */
public final class Ops {

	/**
	 * 获取当前对象的的全量类名
	 * 
	 * @param o
	 * @return
	 */
	public static String getName(Object o) {
		return o.getClass().getName();
	}

	/**
	 * 获取当前对象的的精简类名
	 * 
	 * @param o
	 * @return
	 */
	public static String getSimpleName(Object o) {
		return o.getClass().getSimpleName();
	}

	/**
	 * 获取当前对象的的精简类名
	 * 
	 * @param o
	 * @return
	 */
	public static String getSimpleName(Method method) {
		return method.getDeclaringClass().getSimpleName();
	}

	/**
	 * 实例化
	 * 
	 * @return
	 */
	public static Object newObject() {
		return new Object();
	}

	/**
	 * 转换对象
	 * 
	 * @param e
	 * @return
	 */
	@SuppressWarnings("unchecked")
	public static <T> T formatObject(Object e) {
		return (T) e;
	}

	/**
	 * 获取参数对象的hashcode
	 * 
	 * @param e
	 * @return
	 */
	public static String getCode(Object e) {
		return valueOf(e.hashCode());
	}

	/**
	 * 获取对象状态
	 * 
	 * @param e
	 * @return
	 */
	public static String getStatus(Object o) {
		if (o != null) {
			return o.getClass().getName() + "_" + o.hashCode() + "_" + System.currentTimeMillis();
		}
		return Ops.getMillis();
	}

	/**
	 * 将基本数据类型转化为字符串
	 * 
	 * @param e
	 * @return
	 */
	public static String valueOf(Object e) {
		return EasyBuffer.valueOf(e);
	}

	/**
	 * 截取字符串
	 * 
	 * @param s
	 * @param length
	 * @return
	 */
	public static String substring(String s, int length) {
		if (Ops.isNotEmpty(s) && s.length() > length) {
			return s.substring(0, length);
		}
		return s;
	}

	/**
	 * 判断参数对象是否不为空
	 * 
	 * @param es
	 * @return
	 */
	public static boolean isNull(Object o) {
		return o == null;
	}

	/**
	 * 判断参数对象是否不为空
	 * 
	 * @param es
	 * @return
	 */
	public static boolean isNotNull(Object o) {
		return o != null;
	}

	/**
	 * 判断参数对象是否为空
	 * 
	 * @param es
	 * @return
	 */
	public static <E> boolean isNull(E[] es) {
		return es == null || es.length == 0;
	}

	/**
	 * 判断参数对象是否不为空
	 * 
	 * @param es
	 * @return
	 */
	public static <E> boolean isNotNull(E[] es) {
		return !isNull(es);
	}

	/**
	 * 判断参数对象是否不为空
	 * 
	 * @param es
	 * @return
	 */
	public static boolean isNotNull(String... es) {
		return !isNull(Arrays.asList(es));
	}

	/**
	 * 判断参数List是否为空
	 * 
	 * @param list
	 * @return
	 */
	public static boolean isNull(List<?> list) {
		return list == null || list.isEmpty();
	}

	/**
	 * 判断参数List是否不为空
	 * 
	 * @param list
	 * @return
	 */
	public static boolean isNotNull(List<?> list) {
		return !isNull(list);
	}

	/**
	 * 判断对象是否为空或""
	 * 
	 * @param s
	 * @return
	 */
	public static boolean isEmpty(Object s) {
		return s == null || "".equals(s);
	}

	/**
	 * 判断对象是否不为空或""
	 * 
	 * @param key
	 * @return
	 */
	public static boolean isNotEmpty(Object s) {
		return s != null && !"".equals(s);
	}

	/**
	 * 获取当前字符串形式时间(精确到毫秒)
	 * 
	 * @return
	 */
	public static String getNowMs() {
		return DateUtils.getNowMs();
	}

	/**
	 * 获取当前字符串形式时间
	 * 
	 * @return
	 */
	public static String getNow(String... patterns) {
		return DateUtils.getNow(patterns);
	}

	/**
	 * 获取当前字符串形式时间
	 * 
	 * @return
	 */
	public static String formatDate(String format, Date date) {
		return new SimpleDateFormat(format).format(date);
	}

	/**
	 * 获取当前时间戳
	 * 
	 * @return
	 */
	public static String getMillis() {
		return valueOf(System.currentTimeMillis());
	}

	/**
	 * getValue
	 * 
	 * @param value
	 * @param staticValue
	 * @return
	 */
	public static String getValue(String value) {
		return isNotEmpty(value) ? value : "";
	}

	/**
	 * getValue
	 * 
	 * @param value
	 * @param staticValue
	 * @return
	 */
	public static String getValue(String value, String defaultValue) {
		return isNotEmpty(value) ? value : defaultValue;
	}

	/**
	 * 是否全部相等
	 * 
	 * @param s
	 * @param target
	 * @return
	 */
	public static boolean equals(Object source, Object... targets) {
		if (isEmpty(source) || targets == null || targets.length == 0) {
			return false;
		}
		for (Object target : targets) {
			if (!source.equals(target)) {
				return false;
			}
		}
		return true;
	}

	/**
	 * 是否和其中一个相等
	 * 
	 * @param s
	 * @param target
	 * @return
	 */
	public static boolean in(Object source, Object... targets) {
		for (Object target : targets) {
			if (equals(source, target)) {
				return true;
			}
		}
		return false;
	}

	/**
	 * 是否全部不相等
	 * 
	 * @param s
	 * @param target
	 * @return
	 */
	public static boolean nequals(Object source, Object... targets) {
		return !equals(source, targets);
	}

	/**
	 * 是否和任意一个不相等
	 * 
	 * @param s
	 * @param target
	 * @return
	 */
	public static boolean nin(Object source, Object... targets) {
		return !in(source, targets);
	}

	static final Random random = new Random();

	/**
	 * random
	 * 
	 * @return
	 */
	public static Random random() {
		return random;
	}

	/**
	 * 原始版UUID
	 * 
	 * @return
	 */
	public static String randomUUID() {
		return UUID.randomUUID().toString();
	}

	/**
	 * 简单版UUID
	 * 
	 * @return
	 */
	public static String simpleUUID() {
		return UUID.randomUUID().toString().replace("-", "");
	}

	/**
	 * 将普通字符串转换为十六进制
	 * 
	 * @param s
	 * @return
	 */
	public static String toHex(String s) {
		return HexUtils.toHex(s);
	}

	/**
	 * 将十六进制转化为普通字符串
	 * 
	 * @param s
	 * @return
	 */
	public static String fromHex(String s) {
		return HexUtils.fromHex(s);
	}

	/**
	 * 解析JSON对象
	 * 
	 * @param s
	 * @return
	 */
	public static JSONObject parse(String s) {
		return JSON.parseObject(s);
	}

	/**
	 * 将对象转换为json字符串
	 * 
	 * @param e
	 * @return
	 */
	public static String toJson(Object e) {
		return JSON.toJSONString(e);
	}

	/**
	 * 将map转化为以指定分隔符分隔的字符串
	 * 
	 * @param map
	 * @param separator
	 * @return
	 */
	public static String toString(Map<?, ?> map, String separator) {
		EasyBuffer sb = new EasyBuffer();
		for (Object key : map.keySet()) {
			sb.append(key).append("=").append(map.get(key)).append(separator);
		}
		return sb.clearEnd(separator.length());
	}

	/**
	 * 将map转化为以","作为分隔符的字符串
	 * 
	 * @param map
	 * @return
	 */
	public static String toString(Map<?, ?> map) {
		return toString(map, ",");
	}

	/**
	 * 将list转化为以指定分隔符分隔的字符串
	 * 
	 * @param es
	 * @param separator
	 * @return
	 */
	public static String toString(List<?> es, String separator) {
		EasyBuffer sb = new EasyBuffer();
		for (Object e : es) {
			if (Ops.isNotEmpty(e)) {
				sb.append(e).append(separator);
			}
		}
		return sb.clearEnd(separator.length());
	}

	/**
	 * 将list转化为以","作为分隔符的字符串
	 * 
	 * @param es
	 * @return
	 */
	public static String toString(List<?> es) {
		return toString(es, ",");
	}

	/**
	 * 将数组转化为指定分隔符分隔的字符串
	 * 
	 * @param es
	 * @param separator
	 * @return
	 */
	public static String toString(Object[] es, String separator) {
		return toString(new ArrayList<Object>(Arrays.asList(es)), separator);
	}

	/**
	 * 将数组转化为以","作为分隔符分隔的字符串
	 * 
	 * @param es
	 * @return
	 */
	public static String toString(Object[] es) {
		return toString(es, ",");
	}

	/**
	 * 小写字符串第一个字母
	 * 
	 * @param s
	 * @return
	 */
	public static String toLowCase(String s) {
		return EasyBuffer.wrapper(s.substring(0, 1).toLowerCase(), s.substring(1));
	}

	/**
	 * 大写字符串第一个字母
	 * 
	 * @param s
	 * @return
	 */
	public static String toUpCase(String s) {
		return EasyBuffer.wrapper(s.substring(0, 1).toUpperCase(), s.substring(1));
	}

	/**
	 * 获取指定类的日志对象
	 * 
	 * @param tClass
	 * @return
	 */
	public static Logger getLogger(Class<?> tClass) {
		return LoggerFactory.getLogger(tClass);
	}
}
